home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d982.lha / HWGRCS / HWGpatchP1_2_1.lha / patch-2.1 / src / pch.c < prev    next >
C/C++ Source or Header  |  1993-11-30  |  42KB  |  1,306 lines
  1. /* $Header: pch.c,v 2.0.1.7 88/06/03 15:13:28 lwall Locked $
  2.  *
  3.  * $Log:        pch.c,v $
  4.  * Revision 2.0.2.0  90/05/01  22:17:51  davison
  5.  * patch12u: unidiff support added
  6.  *
  7.  * Revision 2.0.1.7  88/06/03  15:13:28  lwall
  8.  * patch10: Can now find patches in shar scripts.
  9.  * patch10: Hunks that swapped and then swapped back could core dump.
  10.  *
  11.  * Revision 2.0.1.6  87/06/04  16:18:13  lwall
  12.  * pch_swap didn't swap p_bfake and p_efake.
  13.  *
  14.  * Revision 2.0.1.5  87/01/30  22:47:42  lwall
  15.  * Improved responses to mangled patches.
  16.  *
  17.  * Revision 2.0.1.4  87/01/05  16:59:53  lwall
  18.  * New-style context diffs caused double call to free().
  19.  *
  20.  * Revision 2.0.1.3  86/11/14  10:08:33  lwall
  21.  * Fixed problem where a long pattern wouldn't grow the hunk.
  22.  * Also restored p_input_line when backtracking so error messages are right.
  23.  *
  24.  * Revision 2.0.1.2  86/11/03  17:49:52  lwall
  25.  * New-style delete triggers spurious assertion error.
  26.  *
  27.  * Revision 2.0.1.1  86/10/29  15:52:08  lwall
  28.  * Could falsely report new-style context diff.
  29.  *
  30.  * Revision 2.0  86/09/17  15:39:37  lwall
  31.  * Baseline for netwide release.
  32.  *
  33.  */
  34.  
  35. #include "EXTERN.h"
  36. #include "common.h"
  37. #include "util.h"
  38. #include "INTERN.h"
  39. #include "pch.h"
  40.  
  41. /* Patch (diff listing) abstract type. */
  42.  
  43. static long p_filesize;                 /* size of the patch file */
  44. static LINENUM p_first;                 /* 1st line number */
  45. static LINENUM p_newfirst;              /* 1st line number of replacement */
  46. static LINENUM p_ptrn_lines;            /* # lines in pattern */
  47. static LINENUM p_repl_lines;            /* # lines in replacement text */
  48. static LINENUM p_end = -1;              /* last line in hunk */
  49. static LINENUM p_max;                   /* max allowed value of p_end */
  50. static LINENUM p_context = 3;           /* # of context lines */
  51. static LINENUM p_input_line = 0;        /* current line # from patch file */
  52. static char **p_line = Null(char**);    /* the text of the hunk */
  53. static short *p_len = Null(short*);     /* length of each line */
  54. static char *p_Char = Nullch;           /* +, -, and ! */
  55. static int hunkmax = INITHUNKMAX;       /* size of above arrays to begin with */
  56. static int p_indent;                    /* indent to patch */
  57. static LINENUM p_base;                  /* where to intuit this time */
  58. static LINENUM p_bline;                 /* line # of p_base */
  59. static LINENUM p_start;                 /* where intuit found a patch */
  60. static LINENUM p_sline;                 /* and the line number for it */
  61. static LINENUM p_hunk_beg;              /* line number of current hunk */
  62. static LINENUM p_efake = -1;            /* end of faked up lines--don't free */
  63. static LINENUM p_bfake = -1;            /* beg of faked up lines */
  64.  
  65. /* Prepare to look for the next patch in the patch file. */
  66.  
  67. void
  68. re_patch()
  69. {
  70.     p_first = Nulline;
  71.     p_newfirst = Nulline;
  72.     p_ptrn_lines = Nulline;
  73.     p_repl_lines = Nulline;
  74.     p_end = (LINENUM)-1;
  75.     p_max = Nulline;
  76.     p_indent = 0;
  77. }
  78.  
  79. /* Open the patch file at the beginning of time. */
  80.  
  81. void
  82. open_patch_file(filename)
  83. char *filename;
  84. {
  85.     if (filename == Nullch || !*filename || strEQ(filename, "-")) {
  86.         pfp = fopen(TMPPATNAME, "w");
  87.         if (pfp == Nullfp)
  88.             pfatal2("can't create %s", TMPPATNAME);
  89.         while (fgets(buf, sizeof buf, stdin) != Nullch)
  90.             fputs(buf, pfp);
  91.         Fclose(pfp);
  92.         filename = TMPPATNAME;
  93.     }
  94.     pfp = fopen(filename, "r");
  95.     if (pfp == Nullfp)
  96.         pfatal2("patch file %s not found", filename);
  97.     Fstat(fileno(pfp), &filestat);
  98.     p_filesize = filestat.st_size;
  99.     next_intuit_at(0L,1L);                      /* start at the beginning */
  100.     set_hunkmax();
  101. }
  102.  
  103. /* Make sure our dynamically realloced tables are malloced to begin with. */
  104.  
  105. void
  106. set_hunkmax()
  107. {
  108. #ifndef lint
  109.     if (p_line == Null(char**))
  110.         p_line = (char**) malloc((MEM)hunkmax * sizeof(char *));
  111.     if (p_len == Null(short*))
  112.         p_len  = (short*) malloc((MEM)hunkmax * sizeof(short));
  113. #endif
  114.     if (p_Char == Nullch)
  115.         p_Char = (char*)  malloc((MEM)hunkmax * sizeof(char));
  116. }
  117.  
  118. /* Enlarge the arrays containing the current hunk of patch. */
  119.  
  120. void
  121. grow_hunkmax()
  122. {
  123.     hunkmax *= 2;
  124.     /*
  125.      * Note that on most systems, only the p_line array ever gets fresh memory
  126.      * since p_len can move into p_line's old space, and p_Char can move into
  127.      * p_len's old space.  Not on PDP-11's however.  But it doesn't matter.
  128.      */
  129.     assert(p_line != Null(char**) && p_len != Null(short*) && p_Char != Nullch);
  130. #ifndef lint
  131.     p_line = (char**) realloc((char*)p_line, (MEM)hunkmax * sizeof(char *));
  132.     p_len  = (short*) realloc((char*)p_len,  (MEM)hunkmax * sizeof(short));
  133.     p_Char = (char*)  realloc((char*)p_Char, (MEM)hunkmax * sizeof(char));
  134. #endif
  135.     if (p_line != Null(char**) && p_len != Null(short*) && p_Char != Nullch)
  136.         return;
  137.     if (!using_plan_a)
  138.         fatal1("out of memory\n");
  139.     out_of_mem = TRUE;          /* whatever is null will be allocated again */
  140.                                 /* from within plan_a(), of all places */
  141. }
  142.  
  143. /* True if the remainder of the patch file contains a diff of some sort. */
  144.  
  145. bool
  146. there_is_another_patch()
  147. {
  148.     if (p_base != 0L && p_base >= p_filesize) {
  149.         if (verbose)
  150.             say1("done\n");
  151.         return FALSE;
  152.     }
  153.     if (verbose)
  154.         say1("Hmm...");
  155.     diff_type = intuit_diff_type();
  156.     if (!diff_type) {
  157.         if (p_base != 0L) {
  158.             if (verbose)
  159.                 say1("  Ignoring the trailing garbage.\ndone\n");
  160.         }
  161.         else
  162.             say1("  I can't seem to find a patch in there anywhere.\n");
  163.         return FALSE;
  164.     }
  165.     if (verbose)
  166.         say3("  %sooks like %s to me...\n",
  167.             (p_base == 0L ? "L" : "The next patch l"),
  168.             diff_type == UNI_DIFF ? "a unified diff" :
  169.             diff_type == CONTEXT_DIFF ? "a context diff" :
  170.             diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
  171.             diff_type == NORMAL_DIFF ? "a normal diff" :
  172.             "an ed script" );
  173.     if (p_indent && verbose)
  174.         say3("(Patch is indented %d space%s.)\n", p_indent, p_indent==1?"":"s");
  175.     skip_to(p_start,p_sline);
  176.     while (filearg[0] == Nullch) {
  177.         if (force || batch) {
  178.             say1("No file to patch.  Skipping...\n");
  179.             filearg[0] = savestr(bestguess);
  180.             return TRUE;
  181.         }
  182.         ask1("File to patch: ");
  183.         if (*buf != '\n') {
  184.             if (bestguess)
  185.                 free(bestguess);
  186.             bestguess = savestr(buf);
  187.             filearg[0] = fetchname(buf, 0, FALSE);
  188.         }
  189.         if (filearg[0] == Nullch) {
  190.             ask1("No file found--skip this patch? [n] ");
  191.             if (*buf != 'y') {
  192.                 continue;
  193.             }
  194.             if (verbose)
  195.                 say1("Skipping patch...\n");
  196.             filearg[0] = fetchname(bestguess, 0, TRUE);
  197.             skip_rest_of_patch = TRUE;
  198.             return TRUE;
  199.         }
  200.     }
  201.     return TRUE;
  202. }
  203.  
  204. /* Determine what kind of diff is in the remaining part of the patch file. */
  205.  
  206. int
  207. intuit_diff_type()
  208. {
  209.     Reg4 long this_line = 0;
  210.     Reg5 long previous_line;
  211.     Reg6 long first_command_line = -1;
  212.     long fcl_line = 0;
  213.     Reg7 bool last_line_was_command = FALSE;
  214.     Reg8 bool this_is_a_command = FALSE;
  215.     Reg9 bool stars_last_line = FALSE;
  216.     Reg10 bool stars_this_line = FALSE;
  217.     Reg3 int indent;
  218.     Reg1 char *s;
  219.     Reg2 char *t;
  220.     char *indtmp = Nullch;
  221.     char *oldtmp = Nullch;
  222.     char *newtmp = Nullch;
  223.     char *indname = Nullch;
  224.     char *oldname = Nullch;
  225.     char *newname = Nullch;
  226.     Reg11 int retval;
  227.     bool no_filearg = (filearg[0] == Nullch);
  228.  
  229.     ok_to_create_file = FALSE;
  230.     Fseek(pfp, p_base, 0);
  231.     p_input_line = p_bline - 1;
  232.     for (;;) {
  233.         previous_line = this_line;
  234.         last_line_was_command = this_is_a_command;
  235.         stars_last_line = stars_this_line;
  236.         this_line = ftell(pfp);
  237.         indent = 0;
  238.         p_input_line++;
  239.         if (fgets(buf, sizeof buf, pfp) == Nullch) {
  240.             if (first_command_line >= 0L) {
  241.                                         /* nothing but deletes!? */
  242.                 p_start = first_command_line;
  243.                 p_sline = fcl_line;
  244.                 retval = ED_DIFF;
  245.                 goto scan_exit;
  246.             }
  247.             else {
  248.                 p_start = this_line;
  249.                 p_sline = p_input_line;
  250.                 retval = 0;
  251.                 goto scan_exit;
  252.             }
  253.         }
  254.         for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) {
  255.             if (*s == '\t')
  256.                 indent += 8 - (indent % 8);
  257.             else
  258.                 indent++;
  259.         }
  260.         for (t=s; isdigit(*t) || *t == ','; t++) ;
  261.         this_is_a_command = (isdigit(*s) &&
  262.           (*t == 'd' || *t == 'c' || *t == 'a') );
  263.         if (first_command_line < 0L && this_is_a_command) {
  264.             first_command_line = this_line;
  265.             fcl_line = p_input_line;
  266.             p_indent = indent;          /* assume this for now */
  267.         }
  268.         if (!stars_last_line && strnEQ(s, "*** ", 4))
  269.             oldtmp = savestr(s+4);
  270.         else if (strnEQ(s, "--- ", 4))
  271.             newtmp = savestr(s+4);
  272.         else if (strnEQ(s, "+++ ", 4))
  273.             oldtmp = savestr(s+4);      /* pretend it is the old name */
  274.         else if (strnEQ(s, "Index:", 6))
  275.             indtmp = savestr(s+6);
  276.         else if (strnEQ(s, "Prereq:", 7)) {
  277.             for (t=s+7; isspace(*t); t++) ;
  278.             revision = savestr(t);
  279.             for (t=revision; *t && !isspace(*t); t++) ;
  280.             *t = '\0';
  281.             if (!*revision) {
  282.                 free(revision);
  283.                 revision = Nullch;
  284.             }
  285.         }
  286.         if ((!diff_type || diff_type == ED_DIFF) &&
  287.           first_command_line >= 0L &&
  288.           strEQ(s, ".\n") ) {
  289.             p_indent = indent;
  290.             p_start = first_command_line;
  291.             p_sline = fcl_line;
  292.             retval = ED_DIFF;
  293.             goto scan_exit;
  294.         }
  295.         if ((!diff_type || diff_type == UNI_DIFF) && strnEQ(s, "@@ -", 4)) {
  296.             if (!atol(s+3))
  297.                 ok_to_create_file = TRUE;
  298.             p_indent = indent;
  299.             p_start = this_line;
  300.             p_sline = p_input_line;
  301.             retval = UNI_DIFF;
  302.             goto scan_exit;
  303.         }
  304.         stars_this_line = strnEQ(s, "********", 8);
  305.         if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
  306.                  strnEQ(s, "*** ", 4)) {
  307.             if (!atol(s+4))
  308.                 ok_to_create_file = TRUE;
  309.             /* if this is a new context diff the character just before */
  310.             /* the newline is a '*'. */
  311.             while (*s != '\n')
  312.                 s++;
  313.             p_indent = indent;
  314.             p_start = previous_line;
  315.             p_sline = p_input_line - 1;
  316.             retval = (*(s-1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
  317.             goto scan_exit;
  318.         }
  319.         if ((!diff_type || diff_type == NORMAL_DIFF) &&
  320.           last_line_was_command &&
  321.           (strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2)) ) {
  322.             p_start = previous_line;
  323.             p_sline = p_input_line - 1;
  324.             p_indent = indent;
  325.             retval = NORMAL_DIFF;
  326.             goto scan_exit;
  327.         }
  328.     }
  329.   scan_exit:
  330.     if (no_filearg) {
  331.         if (indtmp != Nullch)
  332.             indname = fetchname(indtmp, strippath, ok_to_create_file);
  333.         if (oldtmp != Nullch)
  334.             oldname = fetchname(oldtmp, strippath, ok_to_create_file);
  335.         if (newtmp != Nullch)
  336.             newname = fetchname(newtmp, strippath, ok_to_create_file);
  337.         if (oldname && newname) {
  338.             if (strlen(oldname) < strlen(newname))
  339.                 filearg[0] = savestr(oldname);
  340.             else
  341.                 filearg[0] = savestr(newname);
  342.         }
  343.         else if (oldname)
  344.             filearg[0] = savestr(oldname);
  345.         else if (newname)
  346.             filearg[0] = savestr(newname);
  347.         else if (indname)
  348.             filearg[0] = savestr(indname);
  349.     }
  350.     if (bestguess) {
  351.         free(bestguess);
  352.         bestguess = Nullch;
  353.     }
  354.     if (filearg[0] != Nullch)
  355.         bestguess = savestr(filearg[0]);
  356.     else if (indtmp != Nullch)
  357.         bestguess = fetchname(indtmp, strippath, TRUE);
  358.     else {
  359.         if (oldtmp != Nullch)
  360.             oldname = fetchname(oldtmp, strippath, TRUE);
  361.         if (newtmp != Nullch)
  362.             newname = fetchname(newtmp, strippath, TRUE);
  363.         if (oldname && newname) {
  364.             if (strlen(oldname) < strlen(newname))
  365.                 bestguess = savestr(oldname);
  366.             else
  367.                 bestguess = savestr(newname);
  368.         }
  369.         else if (oldname)
  370.             bestguess = savestr(oldname);
  371.         else if (newname)
  372.             bestguess = savestr(newname);
  373.     }
  374.     if (indtmp != Nullch)
  375.         free(indtmp);
  376.     if (oldtmp != Nullch)
  377.         free(oldtmp);
  378.     if (newtmp != Nullch)
  379.         free(newtmp);
  380.     if (indname != Nullch)
  381.         free(indname);
  382.     if (oldname != Nullch)
  383.         free(oldname);
  384.     if (newname != Nullch)
  385.         free(newname);
  386.     return retval;
  387. }
  388.  
  389. /* Remember where this patch ends so we know where to start up again. */
  390.  
  391. void
  392. next_intuit_at(file_pos,file_line)
  393. long file_pos;
  394. long file_line;
  395. {
  396.     p_base = file_pos;
  397.     p_bline = file_line;
  398. }
  399.  
  400. /* Basically a verbose fseek() to the actual diff listing. */
  401.  
  402. void
  403. skip_to(file_pos,file_line)
  404. long file_pos;
  405. long file_line;
  406. {
  407.     char *ret;
  408.  
  409.     assert(p_base <= file_pos);
  410.     if (verbose && p_base < file_pos) {
  411.         Fseek(pfp, p_base, 0);
  412.         say1("The text leading up to this was:\n--------------------------\n");
  413.         while (ftell(pfp) < file_pos) {
  414.             ret = fgets(buf, sizeof buf, pfp);
  415.             assert(ret != Nullch);
  416.             say2("|%s", buf);
  417.         }
  418.         say1("--------------------------\n");
  419.     }
  420.     else
  421.         Fseek(pfp, file_pos, 0);
  422.     p_input_line = file_line - 1;
  423. }
  424.  
  425. /* Make this a function for better debugging.  */
  426. static void
  427. malformed ()
  428. {
  429.     fatal3("malformed patch at line %ld: %s", p_input_line, buf);
  430.                 /* about as informative as "Syntax error" in C */
  431. }
  432.  
  433. /* True if there is more of the current diff listing to process. */
  434.  
  435. bool
  436. another_hunk()
  437. {
  438.     Reg1 char *s;
  439.     Reg8 char *ret;
  440.     Reg2 int context = 0;
  441.  
  442.     while (p_end >= 0) {
  443.         if (p_end == p_efake)
  444.             p_end = p_bfake;            /* don't free twice */
  445.         else
  446.             free(p_line[p_end]);
  447.         p_end--;
  448.     }
  449.     assert(p_end == -1);
  450.     p_efake = -1;
  451.  
  452.     p_max = hunkmax;                    /* gets reduced when --- found */
  453.     if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) {
  454.         long line_beginning = ftell(pfp);
  455.                                         /* file pos of the current line */
  456.         LINENUM repl_beginning = 0;     /* index of --- line */
  457.         Reg4 LINENUM fillcnt = 0;       /* #lines of missing ptrn or repl */
  458.         Reg5 LINENUM fillsrc;           /* index of first line to copy */
  459.         Reg6 LINENUM filldst;           /* index of first missing line */
  460.         bool ptrn_spaces_eaten = FALSE; /* ptrn was slightly misformed */
  461.         Reg9 bool repl_could_be_missing = TRUE;
  462.                                         /* no + or ! lines in this hunk */
  463.         bool repl_missing = FALSE;      /* we are now backtracking */
  464.         long repl_backtrack_position = 0;
  465.                                         /* file pos of first repl line */
  466.         LINENUM repl_patch_line;        /* input line number for same */
  467.         Reg7 LINENUM ptrn_copiable = 0;
  468.                                         /* # of copiable lines in ptrn */
  469.  
  470.         ret = pgets(buf, sizeof buf, pfp);
  471.         p_input_line++;
  472.         if (ret == Nullch || strnNE(buf, "********", 8)) {
  473.             next_intuit_at(line_beginning,p_input_line);
  474.             return FALSE;
  475.         }
  476.         p_context = 100;
  477.         p_hunk_beg = p_input_line + 1;
  478.         while (p_end < p_max) {
  479.             line_beginning = ftell(pfp);
  480.             ret = pgets(buf, sizeof buf, pfp);
  481.             p_input_line++;
  482.             if (ret == Nullch) {
  483.                 if (p_max - p_end < 4)
  484.                     Strcpy(buf, "  \n");  /* assume blank lines got chopped */
  485.                 else {
  486.                     if (repl_beginning && repl_could_be_missing) {
  487.                         repl_missing = TRUE;
  488.                         goto hunk_done;
  489.                     }
  490.                     fatal1("unexpected end of file in patch\n");
  491.                 }
  492.             }
  493.             p_end++;
  494.             assert(p_end < hunkmax);
  495.             p_Char[p_end] = *buf;
  496. #ifdef zilog
  497.             p_line[(short)p_end] = Nullch;
  498. #else
  499.             p_line[p_end] = Nullch;
  500. #endif
  501.             switch (*buf) {
  502.             case '*':
  503.                 if (strnEQ(buf, "********", 8)) {
  504.                     if (repl_beginning && repl_could_be_missing) {
  505.                         repl_missing = TRUE;
  506.                         goto hunk_done;
  507.                     }
  508.                     else
  509.                         fatal2("unexpected end of hunk at line %ld\n",
  510.                             p_input_line);
  511.                 }
  512.                 if (p_end != 0) {
  513.                     if (repl_beginning && repl_could_be_missing) {
  514.                         repl_missing = TRUE;
  515.                         goto hunk_done;
  516.                     }
  517.                     fatal3("unexpected *** at line %ld: %s", p_input_line, buf);
  518.                 }
  519.                 context = 0;
  520.                 p_line[p_end] = savestr(buf);
  521.                 if (out_of_mem) {
  522.                     p_end--;
  523.                     return FALSE;
  524.                 }
  525.                 for (s=buf; *s && !isdigit(*s); s++) ;
  526.                 if (!*s)
  527.                     malformed ();
  528.                 if (strnEQ(s,"0,0",3))
  529.                     strcpy(s,s+2);
  530.                 p_first = (LINENUM) atol(s);
  531.                 while (isdigit(*s)) s++;
  532.                 if (*s == ',') {
  533.                     for (; *s && !isdigit(*s); s++) ;
  534.                     if (!*s)
  535.                         malformed ();
  536.                     p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
  537.                 }
  538.                 else if (p_first)
  539.                     p_ptrn_lines = 1;
  540.                 else {
  541.                     p_ptrn_lines = 0;
  542.                     p_first = 1;
  543.                 }
  544.                 p_max = p_ptrn_lines + 6;       /* we need this much at least */
  545.                 while (p_max >= hunkmax)
  546.                     grow_hunkmax();
  547.                 p_max = hunkmax;
  548.                 break;
  549.             case '-':
  550.                 if (buf[1] == '-') {
  551.                     if (repl_beginning ||
  552.                         (p_end != p_ptrn_lines + 1 + (p_Char[p_end-1] == '\n')))
  553.                     {
  554.                         if (p_end == 1) {
  555.                             /* `old' lines were omitted - set up to fill */
  556.                             /* them in from 'new' context lines. */
  557.                             p_end = p_ptrn_lines + 1;
  558.                             fillsrc = p_end + 1;
  559.                             filldst = 1;
  560.                             fillcnt = p_ptrn_lines;
  561.                         }
  562.                         else {
  563.                             if (repl_beginning) {
  564.                                 if (repl_could_be_missing){
  565.                                     repl_missing = TRUE;
  566.                                     goto hunk_done;
  567.                                 }
  568.                                 fatal3(
  569. "duplicate \"---\" at line %ld--check line numbers at line %ld\n",
  570.                                     p_input_line, p_hunk_beg + repl_beginning);
  571.                             }
  572.                             else {
  573.                                 fatal4(
  574. "%s \"---\" at line %ld--check line numbers at line %ld\n",
  575.                                     (p_end <= p_ptrn_lines
  576.                                         ? "Premature"
  577.                                         : "Overdue" ),
  578.                                     p_input_line, p_hunk_beg);
  579.                             }
  580.                         }
  581.                     }
  582.                     repl_beginning = p_end;
  583.                     repl_backtrack_position = ftell(pfp);
  584.                     repl_patch_line = p_input_line;
  585.                     p_line[p_end] = savestr(buf);
  586.                     if (out_of_mem) {
  587.                         p_end--;
  588.                         return FALSE;
  589.                     }
  590.                     p_Char[p_end] = '=';
  591.                     for (s=buf; *s && !isdigit(*s); s++) ;
  592.                     if (!*s)
  593.                         malformed ();
  594.                     p_newfirst = (LINENUM) atol(s);
  595.                     while (isdigit(*s)) s++;
  596.                     if (*s == ',') {
  597.                         for (; *s && !isdigit(*s); s++) ;
  598.                         if (!*s)
  599.                             malformed ();
  600.                         p_repl_lines = ((LINENUM)atol(s)) - p_newfirst + 1;
  601.                     }
  602.                     else if (p_newfirst)
  603.                         p_repl_lines = 1;
  604.                     else {
  605.                         p_repl_lines = 0;
  606.                         p_newfirst = 1;
  607.                     }
  608.                     p_max = p_repl_lines + p_end;
  609.                     if (p_max > MAXHUNKSIZE)
  610.                         fatal4("hunk too large (%ld lines) at line %ld: %s",
  611.                               p_max, p_input_line, buf);
  612.                     while (p_max >= hunkmax)
  613.                         grow_hunkmax();
  614.                     if (p_repl_lines != ptrn_copiable
  615.                      && (p_context != 0 || p_repl_lines != 1))
  616.                         repl_could_be_missing = FALSE;
  617.                     break;
  618.                 }
  619.                 goto change_line;
  620.             case '+':  case '!':
  621.                 repl_could_be_missing = FALSE;
  622.               change_line:
  623.                 if (buf[1] == '\n' && canonicalize)
  624.                     strcpy(buf+1," \n");
  625.                 if (!isspace(buf[1]) && buf[1] != '>' && buf[1] != '<' &&
  626.                   repl_beginning && repl_could_be_missing) {
  627.                     repl_missing = TRUE;
  628.                     goto hunk_done;
  629.                 }
  630.                 if (context >= 0) {
  631.                     if (context < p_context)
  632.                         p_context = context;
  633.                     context = -1000;
  634.                 }
  635.                 p_line[p_end] = savestr(buf+2);
  636.                 if (out_of_mem) {
  637.                     p_end--;
  638.                     return FALSE;
  639.                 }
  640.                 break;
  641.             case '\t': case '\n':       /* assume the 2 spaces got eaten */
  642.                 if (repl_beginning && repl_could_be_missing &&
  643.                   (!ptrn_spaces_eaten || diff_type == NEW_CONTEXT_DIFF) ) {
  644.                     repl_missing = TRUE;
  645.                     goto hunk_done;
  646.                 }
  647.                 p_line[p_end] = savestr(buf);
  648.                 if (out_of_mem) {
  649.                     p_end--;
  650.                     return FALSE;
  651.                 }
  652.                 if (p_end != p_ptrn_lines + 1) {
  653.                     ptrn_spaces_eaten |= (repl_beginning != 0);
  654.                     context++;
  655.                     if (!repl_beginning)
  656.                         ptrn_copiable++;
  657.                     p_Char[p_end] = ' ';
  658.                 }
  659.                 break;
  660.             case ' ':
  661.                 if (!isspace(buf[1]) &&
  662.                   repl_beginning && repl_could_be_missing) {
  663.                     repl_missing = TRUE;
  664.                     goto hunk_done;
  665.                 }
  666.                 context++;
  667.                 if (!repl_beginning)
  668.                     ptrn_copiable++;
  669.                 p_line[p_end] = savestr(buf+2);
  670.                 if (out_of_mem) {
  671.                     p_end--;
  672.                     return FALSE;
  673.                 }
  674.                 break;
  675.             default:
  676.                 if (repl_beginning && repl_could_be_missing) {
  677.                     repl_missing = TRUE;
  678.                     goto hunk_done;
  679.                 }
  680.                 malformed ();
  681.             }
  682.             /* set up p_len for strncmp() so we don't have to */
  683.             /* assume null termination */
  684.             if (p_line[p_end])
  685.                 p_len[p_end] = strlen(p_line[p_end]);
  686.             else
  687.                 p_len[p_end] = 0;
  688.         }
  689.  
  690.     hunk_done:
  691.         if (p_end >=0 && !repl_beginning)
  692.             fatal2("no --- found in patch at line %ld\n", pch_hunk_beg());
  693.  
  694.         if (repl_missing) {
  695.  
  696.             /* reset state back to just after --- */
  697.             p_input_line = repl_patch_line;
  698.             for (p_end--; p_end > repl_beginning; p_end--)
  699.                 free(p_line[p_end]);
  700.             Fseek(pfp, repl_backtrack_position, 0);
  701.  
  702.             /* redundant 'new' context lines were omitted - set */
  703.             /* up to fill them in from the old file context */
  704.             if (!p_context && p_repl_lines == 1) {
  705.                 p_repl_lines = 0;
  706.                 p_max--;
  707.             }
  708.             fillsrc = 1;
  709.             filldst = repl_beginning+1;
  710.             fillcnt = p_repl_lines;
  711.             p_end = p_max;
  712.         }
  713.         else if (!p_context && fillcnt == 1) {
  714.             /* the first hunk was a null hunk with no context */
  715.             /* and we were expecting one line -- fix it up. */
  716.             while (filldst < p_end) {
  717.                 p_line[filldst] = p_line[filldst+1];
  718.                 p_Char[filldst] = p_Char[filldst+1];
  719.                 p_len[filldst] = p_len[filldst+1];
  720.                 filldst++;
  721.             }
  722. #if 0
  723.             repl_beginning--;           /* this doesn't need to be fixed */
  724. #endif
  725.             p_end--;
  726.             p_first++;                  /* do append rather than insert */
  727.             fillcnt = 0;
  728.             p_ptrn_lines = 0;
  729.         }
  730.  
  731.         if (diff_type == CONTEXT_DIFF &&
  732.           (fillcnt || (p_first > 1 && ptrn_copiable > 2*p_context)) ) {
  733.             if (verbose)
  734.                 say4("%s\n%s\n%s\n",
  735. "(Fascinating--this is really a new-style context diff but without",
  736. "the telltale extra asterisks on the *** line that usually indicate",
  737. "the new style...)");
  738.             diff_type = NEW_CONTEXT_DIFF;
  739.         }
  740.  
  741.         /* if there were omitted context lines, fill them in now */
  742.         if (fillcnt) {
  743.             p_bfake = filldst;          /* remember where not to free() */
  744.             p_efake = filldst + fillcnt - 1;
  745.             while (fillcnt-- > 0) {
  746.                 while (fillsrc <= p_end && p_Char[fillsrc] != ' ')
  747.                     fillsrc++;
  748.                 if (fillsrc > p_end)
  749.                     fatal2("replacement text or line numbers mangled in hunk at line %ld\n",
  750.                         p_hunk_beg);
  751.                 p_line[filldst] = p_line[fillsrc];
  752.                 p_Char[filldst] = p_Char[fillsrc];
  753.                 p_len[filldst] = p_len[fillsrc];
  754.                 fillsrc++; filldst++;
  755.             }
  756.             while (fillsrc <= p_end && fillsrc != repl_beginning &&
  757.               p_Char[fillsrc] != ' ')
  758.                 fillsrc++;
  759. #ifdef DEBUGGING
  760.             if (debug & 64)
  761.                 printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
  762.                     fillsrc,filldst,repl_beginning,p_end+1);
  763. #endif
  764.             assert(fillsrc==p_end+1 || fillsrc==repl_beginning);
  765.             assert(filldst==p_end+1 || filldst==repl_beginning);
  766.         }
  767.     }
  768.     else if (diff_type == UNI_DIFF) {
  769.         long line_beginning = ftell(pfp);
  770.                                         /* file pos of the current line */
  771.         Reg4 LINENUM fillsrc;           /* index of old lines */
  772.         Reg5 LINENUM filldst;           /* index of new lines */
  773.         char ch;
  774.  
  775.         ret = pgets(buf, sizeof buf, pfp);
  776.         p_input_line++;
  777.         if (ret == Nullch || strnNE(buf, "@@ -", 4)) {
  778.             next_intuit_at(line_beginning,p_input_line);
  779.             return FALSE;
  780.         }
  781.         s = buf+4;
  782.         if (!*s)
  783.             malformed ();
  784.         p_first = (LINENUM) atol(s);
  785.         while (isdigit(*s)) s++;
  786.         if (*s == ',') {
  787.             p_ptrn_lines = (LINENUM) atol(++s);
  788.             while (isdigit(*s)) s++;
  789.         } else
  790.             p_ptrn_lines = 1;
  791.         if (*s == ' ') s++;
  792.         if (*s != '+' || !*++s)
  793.             malformed ();
  794.         p_newfirst = (LINENUM) atol(s);
  795.         while (isdigit(*s)) s++;
  796.         if (*s == ',') {
  797.             p_repl_lines = (LINENUM) atol(++s);
  798.             while (isdigit(*s)) s++;
  799.         } else
  800.             p_repl_lines = 1;
  801.         if (*s == ' ') s++;
  802.         if (*s != '@')
  803.             malformed ();
  804.         if (!p_ptrn_lines)
  805.             p_first++;                  /* do append rather than insert */
  806.         p_max = p_ptrn_lines + p_repl_lines + 1;
  807.         while (p_max >= hunkmax)
  808.             grow_hunkmax();
  809.         fillsrc = 1;
  810.         filldst = fillsrc + p_ptrn_lines;
  811.         p_end = filldst + p_repl_lines;
  812.         Sprintf(buf,"*** %ld,%ld ****\n",p_first,p_first + p_ptrn_lines - 1);
  813.         p_line[0] = savestr(buf);
  814.         if (out_of_mem) {
  815.             p_end = -1;
  816.             return FALSE;
  817.         }
  818.         p_Char[0] = '*';
  819.         Sprintf(buf,"--- %ld,%ld ----\n",p_newfirst,p_newfirst+p_repl_lines-1);
  820.         p_line[filldst] = savestr(buf);
  821.         if (out_of_mem) {
  822.             p_end = 0;
  823.             return FALSE;
  824.         }
  825.         p_Char[filldst++] = '=';
  826.         p_context = 100;
  827.         context = 0;
  828.         p_hunk_beg = p_input_line + 1;
  829.         while (fillsrc <= p_ptrn_lines || filldst <= p_end) {
  830.             line_beginning = ftell(pfp);
  831.             ret = pgets(buf, sizeof buf, pfp);
  832.             p_input_line++;
  833.             if (ret == Nullch) {
  834.                 if (p_max - filldst < 3)
  835.                     Strcpy(buf, " \n");  /* assume blank lines got chopped */
  836.                 else {
  837.                     fatal1("unexpected end of file in patch\n");
  838.                 }
  839.             }
  840.             if (*buf == '\t' || *buf == '\n') {
  841.                 ch = ' ';               /* assume the space got eaten */
  842.                 s = savestr(buf);
  843.             }
  844.             else {
  845.                 ch = *buf;
  846.                 s = savestr(buf+1);
  847.             }
  848.             if (out_of_mem) {
  849.                 while (--filldst > p_ptrn_lines)
  850.                     free(p_line[filldst]);
  851.                 p_end = fillsrc-1;
  852.                 return FALSE;
  853.             }
  854.             switch (ch) {
  855.             case '-':
  856.                 if (fillsrc > p_ptrn_lines) {
  857.                     free(s);
  858.                     p_end = filldst-1;
  859.                     malformed ();
  860.                 }
  861.                 p_Char[fillsrc] = ch;
  862.                 p_line[fillsrc] = s;
  863.                 p_len[fillsrc++] = strlen(s);
  864.                 break;
  865.             case '=':
  866.                 ch = ' ';
  867.                 /* FALL THROUGH */
  868.             case ' ':
  869.                 if (fillsrc > p_ptrn_lines) {
  870.                     free(s);
  871.                     while (--filldst > p_ptrn_lines)
  872.                         free(p_line[filldst]);
  873.                     p_end = fillsrc-1;
  874.                     malformed ();
  875.                 }
  876.                 context++;
  877.                 p_Char[fillsrc] = ch;
  878.                 p_line[fillsrc] = s;
  879.                 p_len[fillsrc++] = strlen(s);
  880.                 s = savestr(s);
  881.                 if (out_of_mem) {
  882.                     while (--filldst > p_ptrn_lines)
  883.                         free(p_line[filldst]);
  884.                     p_end = fillsrc-1;
  885.                     return FALSE;
  886.                 }
  887.                 /* FALL THROUGH */
  888.             case '+':
  889.                 if (filldst > p_end) {
  890.                     free(s);
  891.                     while (--filldst > p_ptrn_lines)
  892.                         free(p_line[filldst]);
  893.                     p_end = fillsrc-1;
  894.                     malformed ();
  895.                 }
  896.                 p_Char[filldst] = ch;
  897.                 p_line[filldst] = s;
  898.                 p_len[filldst++] = strlen(s);
  899.                 break;
  900.             default:
  901.                 p_end = filldst;
  902.                 malformed ();
  903.             }
  904.             if (ch != ' ' && context > 0) {
  905.                 if (context < p_context)
  906.                     p_context = context;
  907.                 context = -1000;
  908.             }
  909.         }/* while */
  910.     }
  911.     else {                              /* normal diff--fake it up */
  912.         char hunk_type;
  913.         Reg3 int i;
  914.         LINENUM min, max;
  915.         long line_beginning = ftell(pfp);
  916.  
  917.         p_context = 0;
  918.         ret = pgets(buf, sizeof buf, pfp);
  919.         p_input_line++;
  920.         if (ret == Nullch || !isdigit(*buf)) {
  921.             next_intuit_at(line_beginning,p_input_line);
  922.             return FALSE;
  923.         }
  924.         p_first = (LINENUM)atol(buf);
  925.         for (s=buf; isdigit(*s); s++) ;
  926.         if (*s == ',') {
  927.             p_ptrn_lines = (LINENUM)atol(++s) - p_first + 1;
  928.             while (isdigit(*s)) s++;
  929.         }
  930.         else
  931.             p_ptrn_lines = (*s != 'a');
  932.         hunk_type = *s;
  933.         if (hunk_type == 'a')
  934.             p_first++;                  /* do append rather than insert */
  935.         min = (LINENUM)atol(++s);
  936.         for (; isdigit(*s); s++) ;
  937.         if (*s == ',')
  938.             max = (LINENUM)atol(++s);
  939.         else
  940.             max = min;
  941.         if (hunk_type == 'd')
  942.             min++;
  943.         p_end = p_ptrn_lines + 1 + max - min + 1;
  944.         if (p_end > MAXHUNKSIZE)
  945.             fatal4("hunk too large (%ld lines) at line %ld: %s",
  946.                   p_end, p_input_line, buf);
  947.         while (p_end >= hunkmax)
  948.             grow_hunkmax();
  949.         p_newfirst = min;
  950.         p_repl_lines = max - min + 1;
  951.         Sprintf(buf, "*** %ld,%ld\n", p_first, p_first + p_ptrn_lines - 1);
  952.         p_line[0] = savestr(buf);
  953.         if (out_of_mem) {
  954.             p_end = -1;
  955.             return FALSE;
  956.         }
  957.         p_Char[0] = '*';
  958.         for (i=1; i<=p_ptrn_lines; i++) {
  959.             ret = pgets(buf, sizeof buf, pfp);
  960.             p_input_line++;
  961.             if (ret == Nullch)
  962.                 fatal2("unexpected end of file in patch at line %ld\n",
  963.                   p_input_line);
  964.             if (*buf != '<')
  965.                 fatal2("< expected at line %ld of patch\n", p_input_line);
  966.             p_line[i] = savestr(buf+2);
  967.             if (out_of_mem) {
  968.                 p_end = i-1;
  969.                 return FALSE;
  970.             }
  971.             p_len[i] = strlen(p_line[i]);
  972.             p_Char[i] = '-';
  973.         }
  974.         if (hunk_type == 'c') {
  975.             ret = pgets(buf, sizeof buf, pfp);
  976.             p_input_line++;
  977.             if (ret == Nullch)
  978.                 fatal2("unexpected end of file in patch at line %ld\n",
  979.                     p_input_line);
  980.             if (*buf != '-')
  981.                 fatal2("--- expected at line %ld of patch\n", p_input_line);
  982.         }
  983.         Sprintf(buf, "--- %ld,%ld\n", min, max);
  984.         p_line[i] = savestr(buf);
  985.         if (out_of_mem) {
  986.             p_end = i-1;
  987.             return FALSE;
  988.         }
  989.         p_Char[i] = '=';
  990.         for (i++; i<=p_end; i++) {
  991.             ret = pgets(buf, sizeof buf, pfp);
  992.             p_input_line++;
  993.             if (ret == Nullch)
  994.                 fatal2("unexpected end of file in patch at line %ld\n",
  995.                     p_input_line);
  996.             if (*buf != '>')
  997.                 fatal2("> expected at line %ld of patch\n", p_input_line);
  998.             p_line[i] = savestr(buf+2);
  999.             if (out_of_mem) {
  1000.                 p_end = i-1;
  1001.                 return FALSE;
  1002.             }
  1003.             p_len[i] = strlen(p_line[i]);
  1004.             p_Char[i] = '+';
  1005.         }
  1006.     }
  1007.     if (reverse)                        /* backwards patch? */
  1008.         if (!pch_swap())
  1009.             say1("Not enough memory to swap next hunk!\n");
  1010. #ifdef DEBUGGING
  1011.     if (debug & 2) {
  1012.         int i;
  1013.         char special;
  1014.  
  1015.         for (i=0; i <= p_end; i++) {
  1016.             if (i == p_ptrn_lines)
  1017.                 special = '^';
  1018.             else
  1019.                 special = ' ';
  1020.             fprintf(stderr, "%3d %c %c %s", i, p_Char[i], special, p_line[i]);
  1021.             Fflush(stderr);
  1022.         }
  1023.     }
  1024. #endif
  1025.     if (p_end+1 < hunkmax)      /* paranoia reigns supreme... */
  1026.         p_Char[p_end+1] = '^';  /* add a stopper for apply_hunk */
  1027.     return TRUE;
  1028. }
  1029.  
  1030. /* Input a line from the patch file, worrying about indentation. */
  1031.  
  1032. char *
  1033. pgets(bf,sz,fp)
  1034. char *bf;
  1035. int sz;
  1036. FILE *fp;
  1037. {
  1038.     char *ret = fgets(bf, sz, fp);
  1039.     Reg1 char *s;
  1040.     Reg2 int indent = 0;
  1041.  
  1042.     if (p_indent && ret != Nullch) {
  1043.         for (s=buf;
  1044.           indent < p_indent && (*s == ' ' || *s == '\t' || *s == 'X'); s++) {
  1045.             if (*s == '\t')
  1046.                 indent += 8 - (indent % 7);
  1047.             else
  1048.                 indent++;
  1049.         }
  1050.         if (buf != s)
  1051.             Strcpy(buf, s);
  1052.     }
  1053.     return ret;
  1054. }
  1055.  
  1056. /* Reverse the old and new portions of the current hunk. */
  1057.  
  1058. bool
  1059. pch_swap()
  1060. {
  1061.     char **tp_line;             /* the text of the hunk */
  1062.     short *tp_len;              /* length of each line */
  1063.     char *tp_char;              /* +, -, and ! */
  1064.     Reg1 LINENUM i;
  1065.     Reg2 LINENUM n;
  1066.     bool blankline = FALSE;
  1067.     Reg3 char *s;
  1068.  
  1069.     i = p_first;
  1070.     p_first = p_newfirst;
  1071.     p_newfirst = i;
  1072.  
  1073.     /* make a scratch copy */
  1074.  
  1075.     tp_line = p_line;
  1076.     tp_len = p_len;
  1077.     tp_char = p_Char;
  1078.     p_line = Null(char**);      /* force set_hunkmax to allocate again */
  1079.     p_len = Null(short*);
  1080.     p_Char = Nullch;
  1081.     set_hunkmax();
  1082.     if (p_line == Null(char**) || p_len == Null(short*) || p_Char == Nullch) {
  1083. #ifndef lint
  1084.         if (p_line == Null(char**))
  1085.             free((char*)p_line);
  1086.         p_line = tp_line;
  1087.         if (p_len == Null(short*))
  1088.             free((char*)p_len);
  1089.         p_len = tp_len;
  1090. #endif
  1091.         if (p_Char == Nullch)
  1092.             free((char*)p_Char);
  1093.         p_Char = tp_char;
  1094.         return FALSE;           /* not enough memory to swap hunk! */
  1095.     }
  1096.  
  1097.     /* now turn the new into the old */
  1098.  
  1099.     i = p_ptrn_lines + 1;
  1100.     if (tp_char[i] == '\n') {           /* account for possible blank line */
  1101.         blankline = TRUE;
  1102.         i++;
  1103.     }
  1104.     if (p_efake >= 0) {                 /* fix non-freeable ptr range */
  1105.         if (p_efake <= i)
  1106.             n = p_end - i + 1;
  1107.         else
  1108.             n = -i;
  1109.         p_efake += n;
  1110.         p_bfake += n;
  1111.     }
  1112.     for (n=0; i <= p_end; i++,n++) {
  1113.         p_line[n] = tp_line[i];
  1114.         p_Char[n] = tp_char[i];
  1115.         if (p_Char[n] == '+')
  1116.             p_Char[n] = '-';
  1117.         p_len[n] = tp_len[i];
  1118.     }
  1119.     if (blankline) {
  1120.         i = p_ptrn_lines + 1;
  1121.         p_line[n] = tp_line[i];
  1122.         p_Char[n] = tp_char[i];
  1123.         p_len[n] = tp_len[i];
  1124.         n++;
  1125.     }
  1126.     assert(p_Char[0] == '=');
  1127.     p_Char[0] = '*';
  1128.     for (s=p_line[0]; *s; s++)
  1129.         if (*s == '-')
  1130.             *s = '*';
  1131.  
  1132.     /* now turn the old into the new */
  1133.  
  1134.     assert(tp_char[0] == '*');
  1135.     tp_char[0] = '=';
  1136.     for (s=tp_line[0]; *s; s++)
  1137.         if (*s == '*')
  1138.             *s = '-';
  1139.     for (i=0; n <= p_end; i++,n++) {
  1140.         p_line[n] = tp_line[i];
  1141.         p_Char[n] = tp_char[i];
  1142.         if (p_Char[n] == '-')
  1143.             p_Char[n] = '+';
  1144.         p_len[n] = tp_len[i];
  1145.     }
  1146.     assert(i == p_ptrn_lines + 1);
  1147.     i = p_ptrn_lines;
  1148.     p_ptrn_lines = p_repl_lines;
  1149.     p_repl_lines = i;
  1150. #ifndef lint
  1151.     if (tp_line == Null(char**))
  1152.         free((char*)tp_line);
  1153.     if (tp_len == Null(short*))
  1154.         free((char*)tp_len);
  1155. #endif
  1156.     if (tp_char == Nullch)
  1157.         free((char*)tp_char);
  1158.     return TRUE;
  1159. }
  1160.  
  1161. /* Return the specified line position in the old file of the old context. */
  1162.  
  1163. LINENUM
  1164. pch_first()
  1165. {
  1166.     return p_first;
  1167. }
  1168.  
  1169. /* Return the number of lines of old context. */
  1170.  
  1171. LINENUM
  1172. pch_ptrn_lines()
  1173. {
  1174.     return p_ptrn_lines;
  1175. }
  1176.  
  1177. /* Return the probable line position in the new file of the first line. */
  1178.  
  1179. LINENUM
  1180. pch_newfirst()
  1181. {
  1182.     return p_newfirst;
  1183. }
  1184.  
  1185. /* Return the number of lines in the replacement text including context. */
  1186.  
  1187. LINENUM
  1188. pch_repl_lines()
  1189. {
  1190.     return p_repl_lines;
  1191. }
  1192.  
  1193. /* Return the number of lines in the whole hunk. */
  1194.  
  1195. LINENUM
  1196. pch_end()
  1197. {
  1198.     return p_end;
  1199. }
  1200.  
  1201. /* Return the number of context lines before the first changed line. */
  1202.  
  1203. LINENUM
  1204. pch_context()
  1205. {
  1206.     return p_context;
  1207. }
  1208.  
  1209. /* Return the length of a particular patch line. */
  1210.  
  1211. short
  1212. pch_line_len(line)
  1213. LINENUM line;
  1214. {
  1215.     return p_len[line];
  1216. }
  1217.  
  1218. /* Return the control character (+, -, *, !, etc) for a patch line. */
  1219.  
  1220. char
  1221. pch_char(line)
  1222. LINENUM line;
  1223. {
  1224.     return p_Char[line];
  1225. }
  1226.  
  1227. /* Return a pointer to a particular patch line. */
  1228.  
  1229. char *
  1230. pfetch(line)
  1231. LINENUM line;
  1232. {
  1233.     return p_line[line];
  1234. }
  1235.  
  1236. /* Return where in the patch file this hunk began, for error messages. */
  1237.  
  1238. LINENUM
  1239. pch_hunk_beg()
  1240. {
  1241.     return p_hunk_beg;
  1242. }
  1243.  
  1244. /* Apply an ed script by feeding ed itself. */
  1245.  
  1246. void
  1247. do_ed_script()
  1248. {
  1249.     Reg1 char *t;
  1250.     Reg2 long beginning_of_this_line;
  1251.     Reg3 bool this_line_is_command = FALSE;
  1252.     Reg4 FILE *pipefp;
  1253.  
  1254.     if (!skip_rest_of_patch) {
  1255.         Unlink(TMPOUTNAME);
  1256.         copy_file(filearg[0], TMPOUTNAME);
  1257.         if (verbose)
  1258.             Sprintf(buf, ED_PROG " %s", TMPOUTNAME);
  1259.         else
  1260.             Sprintf(buf, ED_PROG " - %s", TMPOUTNAME);
  1261.         pipefp = popen(buf, "w");
  1262.     }
  1263.     for (;;) {
  1264.         beginning_of_this_line = ftell(pfp);
  1265.         if (pgets(buf, sizeof buf, pfp) == Nullch) {
  1266.             next_intuit_at(beginning_of_this_line,p_input_line);
  1267.             break;
  1268.         }
  1269.         p_input_line++;
  1270.         for (t=buf; isdigit(*t) || *t == ','; t++) ;
  1271.         this_line_is_command = (isdigit(*buf) &&
  1272.           (*t == 'd' || *t == 'c' || *t == 'a') );
  1273.         if (this_line_is_command) {
  1274.             if (!skip_rest_of_patch)
  1275.                 fputs(buf, pipefp);
  1276.             if (*t != 'd') {
  1277.                 while (pgets(buf, sizeof buf, pfp) != Nullch) {
  1278.                     p_input_line++;
  1279.                     if (!skip_rest_of_patch)
  1280.                         fputs(buf, pipefp);
  1281.                     if (strEQ(buf, ".\n"))
  1282.                         break;
  1283.                 }
  1284.             }
  1285.         }
  1286.         else {
  1287.             next_intuit_at(beginning_of_this_line,p_input_line);
  1288.             break;
  1289.         }
  1290.     }
  1291.     if (skip_rest_of_patch)
  1292.         return;
  1293.     fprintf(pipefp, "w\n");
  1294.     fprintf(pipefp, "q\n");
  1295.     Fflush(pipefp);
  1296.     Pclose(pipefp);
  1297.     ignore_signals();
  1298.     if (move_file(TMPOUTNAME, outname) < 0) {
  1299.         toutkeep = TRUE;
  1300.         chmod(TMPOUTNAME, filemode);
  1301.     }
  1302.     else
  1303.         chmod(outname, filemode);
  1304.     set_signals(1);
  1305. }
  1306.